{***********************************
    Trabajo Practico.
    Integrantes:
        Loiacono, Tatiana	        tx.loiacono@gmail.com
        Aguilar Cogan, Damián	        damian.aguilarcogan@gmail.com
        Vicente, Mariano 	        m.vicent@gmail.com
        Bautista, Andres	        andres_abs@hotmail.com
        Engstfeld, Eric		        exengstfeld@hotmail.com
                
************************************}
Program Tp;
Uses
	Dos,crt;
    
Const
        MAX_PEDIDOS = 200;

Type
	TR_Repuestos= Record
                CantFaltante: Word;
                CodRepuesto: Word;
	End;
	
        TV_Repuestos=Array[1..10] of TR_Repuestos;
	
	TP_PedidosFaltantes=    ^TN_Pedido;	
	TP_RepuestosFaltantes=  ^TN_Repuesto;
	TP_SubPedidosRepuesto=  ^TN_SubPedidoRepuesto;
	
	TN_SubPedidoRepuesto=Record
		NumPedido:Word;
		CantFaltante:Word;
		sgte: TP_SubPedidosRepuesto;
	End;
		
	TN_Repuesto=Record
		CodRepuesto:Word;
		SubPedidos: TP_SubPedidosRepuesto;
	        sgte:   TP_RepuestosFaltantes;
	End;
		
	TN_Pedido=Record
		NumPedido: Word;
		RtosFaltantes: TV_Repuestos;
		sgte: TP_PedidosFaltantes;
	End;
         
        FechaString = String[8];
        String30    = String[30]; 

        Pedido=Record
       	        Numero:Word;
       	        Fecha:FechaString;
       	        Electrodomestico:String30;
        End;

        Repuesto=Record
       	        Codigo:Word;
                Descripcion:String30;
                Cantidad:Word;
        End;

        ArrayRepuestos = Array[1..10] of Repuesto;

        PedidoReparado=Record
                Numero:Word;
                Fecha:FechaString;
                RepuestosUtilizados:ArrayRepuestos;
        End;

        FilePedidos         	= File of Pedido;
        FilePedidosReparados	= File of PedidoReparado;
   	FileRepuestos       	= File of Repuesto;
   	
{*********Procedimientos y Funciones***************}

{***Manejo de archivos***}
Function FileExists(Name : String) : boolean;
Var  aFile : File;
Begin
  {$I-}
  Assign(aFile,Name);
  Reset(aFile);
  {$I+}
  FileExists:= ((IOResult=0) And (Name<>''));
  Close (aFile);
End;

Procedure OpenFilePedidos(Var FileAsociated:FilePedidos);
Const
	FileName = 'Pedidos.dat';
Begin    
	Assign(FileAsociated,FileName);
	If (FileExists(FileName)) Then
            	Reset(FileAsociated)
	Else
            	Rewrite(FileAsociated);
End;

Procedure OpenFilePedidosTemporal(Var FileAsociated:FilePedidos);
Const
	FileName = 'Pedidos-Temporal.dat';
Begin    
	Assign(FileAsociated,FileName);
	If (FileExists(FileName)) Then
    	        Reset(FileAsociated)
	Else
    	        Rewrite(FileAsociated);
End;

Procedure OpenFilePedidosReparados(Var FileAsociated:FilePedidosReparados);
Const
	FileName = 'Reparaciones.dat';
Begin    
	Assign(FileAsociated,FileName);
	If (FileExists(FileName)) Then
                Reset(FileAsociated)
	Else
                Rewrite(FileAsociated);
End;

Procedure OpenFileRepuestos(Var FileAsociated:FileRepuestos);
Const
	FileName = 'Repuestos.dat';
Begin    
	Assign(FileAsociated,FileName);

	If (FileExists(FileName)) Then
            	Reset(FileAsociated)
	Else
            	Rewrite(FileAsociated);
End;
{***/Manejo de Archivos***}

{*** Manejo de Pedidos ***}
Function CalcularFechaHoy() : FechaString;
Var Year,Month,Day,WDay: Word;
	DayString,MonthString,YearString:String[4];
Begin
	GetDate(Year,Month,Day,WDay);

	Str(Trunc(Day),DayString);
	Str(Trunc(Year),YearString);
	Str(Trunc(Month),MonthString);

	CalcularFechaHoy := Concat(YearString,MonthString,DayString);
End;

Procedure MensajeDelSistema(Var Mensaje:String);
Begin
        ClrScr;
      	Writeln ('------------------------------------------------');
        Writeln(Mensaje);
	Writeln ('--- Enter para continuar ---');
	Readln;
	ClrScr;
End;

Procedure MostrarErrorArchivoLLeno();
Begin
    ClrScr;
    Writeln ('El numero de pedidos llego a su maximo (',MAX_PEDIDOS,')');
    Writeln ('Primero resuelva algunos pedidos antes de continuar');
    Writeln ('--Enter para continuar--');
    Readln;
End;

Function GenerarNumeroPedido(): Word;
Var
	Archivo : FilePedidos;
	UltimoPedido : Pedido;
Begin
	OpenFilePedidos(Archivo);
	If FileSize(Archivo) > 0 Then
	Begin
            	Seek(Archivo,FileSize(Archivo)-1);
            	Read(Archivo,UltimoPedido);
            	GenerarNumeroPedido:= UltimoPedido.Numero + 1;
	End
	Else
            	GenerarNumeroPedido := 1;
    	{Primer Registro}   	 
	Close(Archivo);
End;


Function ValidarCantidadPedidos(Var PedidoArchivo : FilePedidos) : Boolean;
Begin
	ValidarCantidadPedidos := (FileSize(PedidoArchivo) <= MAX_PEDIDOS);
End;

Procedure InsertarNuevoPedido(Var PedidoArchivo: FilePedidos);
Var
	NuevoPedido : Pedido;
Begin
    
        Writeln('--------Agregar nuevo pedido de reparación------------');
	Writeln('Ingrese El electrodomestico');

	Readln(NuevoPedido.Electrodomestico);
	NuevoPedido.Fecha:= CalcularFechaHoy();
	NuevoPedido.Numero:= GenerarNumeroPedido();

	OpenFilePedidos(PedidoArchivo);
	Seek(PedidoArchivo,FileSize(PedidoArchivo));
	Write(PedidoArchivo,NuevoPedido);
	ClrScr;
End;

Procedure AgregarPedidoReparacion();
Var
	PedidoArchivo:FilePedidos;
Begin
	OpenFilePedidos(PedidoArchivo);
	If ValidarCantidadPedidos(PedidoArchivo) Then
    	        InsertarNuevoPedido(PedidoArchivo)
	Else
	        MostrarErrorArchivoLLeno();

	Close(PedidoArchivo);
End;

{*** /Manejo de Pedidos ***}

{*** Registrar Reparacion ***}
Procedure VisualizarPedido(UnPedido:Pedido);
Begin
	Writeln ('Numero de Pedido: ', UnPedido.Numero);
	Writeln ('Fecha de Pedido: ',  UnPedido.Fecha);
	Writeln ('Electrodomestico: ', UnPedido.Electrodomestico);
End;

Procedure MensajeActualizacion(UnPedido:Pedido);
Begin
	ClrScr;
	Writeln ('------------------------------------------------');
	Writeln ('Se Reparo el pedido:');
	VisualizarPedido(UnPedido);    
	Writeln ('Toda la informacion fue actualizada');
	Writeln ('--Enter para continuar--');
	Readln;
	ClrScr;
End;

Function GenerarNumeroReparacion() : Word;
Var
	Archivo: FilePedidosReparados;
	UltimoPedido : PedidoReparado;

Begin
	OpenFilePedidosReparados(Archivo);

	If FileSize(Archivo) > 0 Then
	Begin
            	Seek(Archivo,FileSize(Archivo)-1);
            	Read(Archivo,UltimoPedido);
            	GenerarNumeroReparacion := UltimoPedido.Numero + 1;
	End
	Else
            	GenerarNumeroReparacion := 1;
            	{Primer registro}
   	 
	Close(Archivo);
End;

Procedure InicializarPedido(Var UnPedido : Pedido);
Begin
	UnPedido.Numero := 0;
	UnPedido.Fecha := '';
	UnPedido.Electrodomestico := '';
End;

Procedure InicializarRepuesto(Var UnRepuesto : Repuesto);
Begin
	UnRepuesto.Codigo := 0;
	UnRepuesto.Descripcion := '';
	UnRepuesto.Cantidad := 0;
End;

Procedure InicializarReparados(Var NuevaReparacion : PedidoReparado);
Var
	RepuestosUsados : Repuesto;
	I,Longitud : Integer;
Begin
        InicializarRepuesto(RepuestosUsados);
        Longitud := Length(NuevaReparacion.RepuestosUtilizados);
        
        For I:=1 To Longitud Do
                NuevaReparacion.RepuestosUtilizados[i] := RepuestosUsados;

End;

Function ObtenerPedidoAntiguo():Pedido;
Var
	PedidoArchivo : FilePedidos;
	UnPedido : Pedido;
Begin
	InicializarPedido(UnPedido);

	If (FileExists('Pedidos.dat')) Then
        Begin          
                OpenFilePedidos(PedidoArchivo);
	        Seek(PedidoArchivo,0);
	        {0 siempre que este ordenado y limpio}
	        Read(PedidoArchivo,UnPedido);    
                Close(PedidoArchivo);
        End;
	
        ObtenerPedidoAntiguo := UnPedido;
End;

Function BuscarRepuesto(RepuestoBuscado : Repuesto): Repuesto;   	 
Var
	Archivo : FileRepuestos;
	RepuestoTemporal : Repuesto;
	Minimo , Maximo , Medio : Integer;    
    
Begin
	OpenFileRepuestos(Archivo);
        {Busqueda Binaria}
	Minimo  := 0;
	Maximo  := FileSize(Archivo);
	Medio   := 0;

	InicializarRepuesto(RepuestoTemporal);
	BuscarRepuesto := RepuestoTemporal;	 

	While ((RepuestoTemporal.Codigo <> RepuestoBuscado.Codigo) And (Minimo <= Maximo)) Do
	Begin            
            	Medio := (Minimo + Maximo) Div 2;   	 
            	Seek(Archivo,Medio);
            	Read(Archivo,RepuestoTemporal);
           	Writeln('Codigo :',RepuestoTemporal.Codigo);
            	 
            	If RepuestoBuscado.Codigo = RepuestoTemporal.Codigo Then
             	        BuscarRepuesto := RepuestoTemporal	 
            	Else If RepuestoBuscado.Codigo > RepuestoTemporal.Codigo Then
                	Minimo := Medio + 1
            	Else If RepuestoBuscado.Codigo < RepuestoTemporal.Codigo Then
                	Maximo := Medio - 1
            	Else
                Begin
                        {No encontro nada}
                        InicializarRepuesto(RepuestoTemporal);   
                        BuscarRepuesto := RepuestoTemporal;
                End;	 
        End;   	 
	Close(Archivo);
End;

Function BuscarPosicionRepuesto(RepuestoBuscado : Repuesto): Integer;   	 
Var
	Archivo : FileRepuestos;
	RepuestoTemporal : Repuesto;
	Minimo , Maximo , Medio : Integer;    
    
Begin
	OpenFileRepuestos(Archivo);
        {Busqueda Binaria}
	Minimo  := 0;
	Maximo  := FileSize(Archivo);
	Medio   := 0;

	BuscarPosicionRepuesto := -1;
    InicializarRepuesto(RepuestoTemporal);
	
    While ((RepuestoTemporal.Codigo <> RepuestoBuscado.Codigo) And (Minimo <= Maximo)) Do
	Begin
            Medio := (Minimo + Maximo) Div 2;   	 
            Seek(Archivo,Medio);
            Read(Archivo,RepuestoTemporal);
            	 
            If RepuestoBuscado.Codigo = RepuestoTemporal.Codigo Then
                    BuscarPosicionRepuesto := Medio    
            Else If RepuestoBuscado.Codigo > RepuestoTemporal.Codigo Then
                    Minimo := Medio +1
            Else If RepuestoBuscado.Codigo < RepuestoTemporal.Codigo Then
                    Maximo := Medio -1
            Else
                   {No encontro nada}
                    BuscarPosicionRepuesto := -1; 
	End;   	 
	Close(Archivo);
End;


Function CantidadUsada(Var RepuestoBuscado : Repuesto; UnPedidoCargado : PedidoReparado): Word;   	 
Var
	RepuestoTemporal : Repuesto;
	I , Maximo  : Integer;
	TotalUsado : Word;    
    
Begin
	TotalUsado := 0;
	Maximo := Length(UnPedidoCargado.RepuestosUtilizados);
	
	For I:= 1 To Maximo Do
	Begin
            	RepuestoTemporal := UnPedidoCargado.RepuestosUtilizados[I];    
           	 
            	If (RepuestoBuscado.Codigo = RepuestoTemporal.Codigo) Then   	 
                	TotalUsado := RepuestoTemporal.Cantidad + TotalUsado;
	End;

	CantidadUsada := TotalUsado;    
End;

Function ValidarRepuesto(Var UnRepuesto:Repuesto; NuevoPedidoReparado : PedidoReparado) : Boolean;
Var
	RepuestoEncontrado : Repuesto;
	RepuestosUsados : Word;
Begin
	InicializarRepuesto(RepuestoEncontrado);    
	RepuestoEncontrado := BuscarRepuesto(UnRepuesto);
	RepuestosUsados    := CantidadUsada(UnRepuesto,NuevoPedidoReparado);
    
	If (RepuestoEncontrado.Codigo = 0) Then
	Begin
            	Writeln('No Existen repuesto con ese codigo');
            	ValidarRepuesto := False;
	End
	Else If (RepuestoEncontrado.Cantidad < UnRepuesto.Cantidad) Then
	Begin
            	Writeln('No alcanza el stock para la reparacion');
            	ValidarRepuesto := False;
	End
	Else If ((RepuestosUsados <> 0) And ((RepuestoEncontrado.Cantidad - RepuestosUsados) < UnRepuesto.Cantidad)) Then
	Begin
            	Writeln('No alcanza el stock para la reparacion');
            	ValidarRepuesto := False;	 
	End  
	Else
           	ValidarRepuesto := True;

End;

Function BuscarRepuesto(Var RepuestosFaltantes:TP_RepuestosFaltantes; CodRepuesto: Word): TP_RepuestosFaltantes;
Const
	ERRORVACIO='Error en función "BuscarRepuesto": Lista vacia';
	ERRORNOENCONTRADO='No se ha encontrado el repuesto';
Var
	PAux : TP_RepuestosFaltantes;
Begin
        If (RepuestosFaltantes <> Nil) Then 
        Begin
        	PAux:= RepuestosFaltantes;
		While (PAux^.CodRepuesto = CodRepuesto) And (PAux=Nil) Do 
        	        PAux := PAux^.sgte;
		
	        If (PAux^.CodRepuesto = CodRepuesto) Then 
	                BuscarRepuesto:=PAux 
	        Else 
	                BuscarRepuesto:= RepuestosFaltantes;
	End 
	Else 
                Writeln(ERRORVACIO)
End;
	
Function BuscarPedido(Var PedidosFaltantes:TP_PedidosFaltantes; NumPedido: Word): TP_PedidosFaltantes;
Const
	ERRORVACIO='Error en función "buscarPedido": Lista vacia';
	ERRORNOENCONTRADO='No se ha encontrado el pedido';
Var
	PAux : TP_PedidosFaltantes;

Begin
	If (PedidosFaltantes <> Nil) Then 
	Begin
	        PAux:= PedidosFaltantes;
		While (PAux^.NumPedido = NumPedido) and (PAux=Nil) Do 
		Begin
			PAux := PAux^.sgte;
		End;
		
		If (PAux^.NumPedido = NumPedido) Then 
		        buscarPedido:=PAux 
		Else 
		        buscarPedido:= PedidosFaltantes;
	End else
	        Writeln(ERRORVACIO)
End;
	
Function ExisteRepuesto(Var RepuestosFaltantes:TP_RepuestosFaltantes; CodRepuesto: Word): boolean;
Var
	PAux : TP_RepuestosFaltantes;
Begin

	PAux:= RepuestosFaltantes;
	While (PAux^.CodRepuesto = CodRepuesto) And (PAux = Nil) Do 
	        PAux := PAux^.sgte;
			
        ExisteRepuesto:= (PAux^.CodRepuesto = CodRepuesto); 
End;
	

Function ExistePedido(Var PedidosFaltantes:TP_PedidosFaltantes; NumPedido: Word): boolean;
Var
	PAux : TP_PedidosFaltantes;
Begin
	PAux:= PedidosFaltantes;

	While (PAux^.NumPedido = NumPedido) and (PAux=Nil) Do 
	        PAux := PAux^.sgte;

	ExistePedido:=(PAux^.NumPedido = NumPedido)
End;

Procedure MostrarPedidos(Var PedidosFaltantes: TP_PedidosFaltantes);
Const
	ERRORVACIO='No hay pedidos que necesiten repuestos';
	CABEZA='Listado de Pedidos que necesitan repuestos';
	ESPACIOS='           ';
	SANGRIA='	';

Var
        PAux: TP_PedidosFaltantes;
	x: Byte;
	
Begin
       	If (PedidosFaltantes<>Nil) Then 
       	Begin
	        PAux:= PedidosFaltantes;
	        Writeln(CABEZA);
		
		While (PAux<>Nil) do 
		Begin
		        Writeln('Número de Pedido: ', PAux^.NumPedido);
			Writeln(SANGRIA, 'Cód. de Repuesto   Cant. Faltante');
			
			For x:= 1 to 10 Do 
			Begin
				Write(SANGRIA);
				Writeln(PAux^.RtosFaltantes[x].CodRepuesto, ESPACIOS, PAux^.RtosFaltantes[x].CantFaltante);
			End;
			
			Writeln();
			PAux:=PAux^.sgte;		
		End;
		End 
		Else 
		        Writeln(ERRORVACIO);
End;

Procedure MostrarRepuestos(Var RepuestosFaltantes:TP_RepuestosFaltantes);
Const
	ERRORVACIO='No hay repuestos faltantes en pedidos';
	CABEZA='Listado de Repuestos con los pedidos que los necesitan';
	ESPACIOS='         ';
	SANGRIA='	';

Var
	PAux: TP_RepuestosFaltantes;
	PSAux: TP_SubPedidosRepuesto;
Begin
	If (RepuestosFaltantes <> Nil) Then 
	Begin
	        PAux:= RepuestosFaltantes;
                Writeln(CABEZA);
		While (PAux<>Nil) Do 
		Begin
	                Writeln('Código de Repuesto: ', PAux^.CodRepuesto);
			Writeln(SANGRIA, 'Núm. Pedido  Cant. Faltante');
			PSAux:= PAux^.SubPedidos;
			While (PSAux<>Nil) Do 
			Begin
				Write(ESPACIOS); 
				Writeln(PSAux^.NumPedido, ESPACIOS, PSAux^.CantFaltante);
				PSAux:=PSAux^.sgte;
			End;
					
			Writeln();
			PAux:=PAux^.sgte;
		End;
		End 
	        Else 
	                Writeln(ERRORVACIO);
End;
		
Procedure VerFaltantesRepuestos(Var PedidosFaltantes: TP_PedidosFaltantes; Var RepuestosFaltantes:TP_RepuestosFaltantes);
Const
    OPCION1='1- Mostrar los pedidos que no se pudieron reparar por falta de stock de repuestos y los repuestos faltantes para cada reparación';
    OPCION2='2- Mostrar los repuestos que resultaron faltantes y todos los pedidos que lo necesitaban que no pudieron ser reparados';
    OPCION3='3- Volver a Menú Principal';

Var
	selec: Byte;
Begin
	Writeln(OPCION1);
	Writeln();
	Writeln(OPCION2);
	Writeln();
	Writeln(OPCION3);
	Writeln();
	
	Repeat
	    ReadLn(selec);
	      
                Case selec Of 
                	1:MostrarPedidos(PedidosFaltantes);
                	2:MostrarRepuestos(RepuestosFaltantes);
                End;
	
        Until selec = 3;    
End;
	
Procedure MeterRepuesto(Var RepuestosFaltantes: TP_RepuestosFaltantes; Cod: Word);
Var
        PAux: TP_RepuestosFaltantes;
Begin
	New(PAux);
	PAux^.CodRepuesto:= Cod;
	PAux^.SubPedidos:= Nil;
	PAux^.sgte:= RepuestosFaltantes;
	RepuestosFaltantes:= PAux;
End;
	
Procedure MeterSubPedidoRepuesto(Var SubPedidos: TP_SubPedidosRepuesto; Numero: word; Cant: Integer);
Var
	PAux: TP_SubPedidosRepuesto;
Begin
	New(PAux);
	PAux^.NumPedido:= Numero;
	PAux^.CantFaltante:= Cant;
	PAux^.sgte:= SubPedidos;
	SubPedidos:= PAux;
End;

Procedure CargaListaRepuestos (Var Pedido: PedidoReparado; Var Repuestos: TV_Repuestos;Var RepuestosFaltantes: TP_RepuestosFaltantes);
Var
	PAux:   TP_RepuestosFaltantes;
	PSAux:  TP_SubPedidosRepuesto;
	I:Byte;
Begin
	For I:= 1 To 10 Do 
	Begin
		If (Repuestos[I].CodRepuesto <> 0) Then 
		Begin
		        ExisteRepuesto(RepuestosFaltantes, Repuestos[I].CodRepuesto)
                {			
			If () Then 
               			PAux := BuscarRepuesto(RepuestosFaltantes, Repuestos[I].CodRepuesto)
			Else 
			        MeterRepuesto(RepuestosFaltantes, Repuestos[I].CodRepuesto);
			PSAux := PAux^.SubPedidos;
			MeterSubPedidoRepuesto(PSAux, Pedido.Numero, Repuestos[I].CantFaltante);
		}
		End;
        End;
End;

Procedure MeterPedido(Numero: word; Var Repuestos: TV_Repuestos; Var PedidosFaltantes: TP_PedidosFaltantes);
Var
        PAux: TP_PedidosFaltantes;	
Begin
	NEW(PAux);
	PAux^.NumPedido:=Numero;
	PAux^.RtosFaltantes:= Repuestos;
	PAux^.sgte:=PedidosFaltantes;
	PedidosFaltantes:=PAux;
End;

Procedure cargaListaPedidos (Var Pedido: PedidoReparado; Var  Repuestos: TV_Repuestos; Var PedidosFaltantes: TP_PedidosFaltantes);
Begin
	If Not(existePedido(PedidosFaltantes, Pedido.Numero)) Then 
	    MeterPedido(Pedido.Numero, Repuestos, PedidosFaltantes);
End;

Procedure DestruirSubPedidosRepuesto(Var SubPedidosRepuesto: TP_SubPedidosRepuesto);
Var
	PSAux : TP_SubPedidosRepuesto;
Begin
	PSAux := SubPedidosRepuesto;
	
	While (PSAux<>Nil) Do 
	Begin
		SubPedidosRepuesto := PSAux^.sgte;
		DISPOSE(PSAux);
		PSAux := SubPedidosRepuesto;
	End;
End;

Procedure DestruirListaRepuestos(Var RepuestosFaltantes: TP_RepuestosFaltantes);
Var
	PAux : TP_RepuestosFaltantes;
Begin
	PAux := RepuestosFaltantes;
	
	While (PAux<>Nil) Do 
	Begin
		RepuestosFaltantes := PAux^.sgte;
		DestruirSubPedidosRepuesto(PAux^.SubPedidos);
		Dispose(PAux);
		PAux:= RepuestosFaltantes;
	End;
End;

Procedure DestruirListaPedidos(Var PedidosFaltantes: TP_PedidosFaltantes);
Var
	PAux : TP_PedidosFaltantes;
    
Begin
	PAux := PedidosFaltantes;
		
	While (PAux<>Nil) Do 
	Begin
		PedidosFaltantes := PAux^.sgte;
		Dispose(PAux);
		PAux:= PedidosFaltantes;
	End;
End;

Procedure DestruirListas(Var PedidosFaltantes: TP_PedidosFaltantes; Var RepuestosFaltantes: TP_RepuestosFaltantes);
Begin
	DestruirListaPedidos(PedidosFaltantes);
	DestruirListaRepuestos(RepuestosFaltantes);
End;

Procedure CargaRespuestosNecesarios(Var NuevoPedidoReparado : PedidoReparado; Var PedidosFaltantes: TP_PedidosFaltantes; Var RepuestosFaltantes: TP_RepuestosFaltantes);
Var
   NuevoRepuesto,RepuestoEncontrado : Repuesto;
   ContadorPedido : Integer;
   Opcion : Char;
   VecRepuestosFaltantes: TV_Repuestos;

Begin
	ContadorPedido:= 1 ;
	Opcion := 'Y';
    
	InicializarRepuesto(NuevoRepuesto);
	InicializarRepuesto(RepuestoEncontrado);    
    
	While ((ContadorPedido <= 10) And (Opcion = 'Y')) Do
	Begin
            	Writeln('Pedido: ',ContadorPedido,'/10');
            	Write('Ingrese Codigo de Respuesto:');        	
            	Readln(NuevoRepuesto.Codigo);

            	Write('Ingrese Cantidad: ');
            	Readln(NuevoRepuesto.Cantidad);
        	            		        
	        VecRepuestosFaltantes[ContadorPedido].CantFaltante := NuevoRepuesto.Cantidad;
	        VecRepuestosFaltantes[ContadorPedido].CodRepuesto  := NuevoRepuesto.Codigo;

            	If ValidarRepuesto(NuevoRepuesto,NuevoPedidoReparado) Then
            	Begin
                        NuevoPedidoReparado.RepuestosUtilizados[ContadorPedido] := NuevoRepuesto;
                        ContadorPedido := ContadorPedido + 1;
            	End
            	Else
            	Begin            	                	
                	{
                        CargaListaRepuestos(NuevoPedidoReparado, vecRepuestosFaltantes, RepuestosFaltantes);
                	CargaListaPedidos(NuevoPedidoReparado, vecRepuestosFaltantes, PedidosFaltantes);
                	}
		End;
            	If ContadorPedido < 10 Then
            	Begin
                	Writeln('Quiere Ingresar otro Respuesto? (Y/N)');
                	Readln (Opcion);
                	ClrScr;
            	End
 	End;
End;

Function NoEstaVacio(RepuestosArray :ArrayRepuestos) : Boolean;
Var
	I, Maximo,CantidadDeRepuestos: Integer;
	RepuestoCargado : Repuesto;
Begin

	Maximo := Length(RepuestosArray);
	CantidadDeRepuestos:= 0;

	For I:=1 To Maximo Do
	Begin
    	        RepuestoCargado := RepuestosArray[I];
    	        If (RepuestoCargado.Codigo <> 0) Then
            	        CantidadDeRepuestos := CantidadDeRepuestos +1;
	End;
	
	NoEstaVacio := (CantidadDeRepuestos > 0);
    
End;

Procedure ActualizarPedidosReparados(Var NuevoPedidoReparado : PedidoReparado);
Var
	Archivo : FilePedidosReparados;
    
Begin
        If  NoEstaVacio(NuevoPedidoReparado.RepuestosUtilizados) Then
	Begin    
            	OpenFilePedidosReparados(Archivo);
            	Seek(Archivo,FileSize(Archivo));
            	Write(Archivo,NuevoPedidoReparado);
            	Close(Archivo);
	End;       	 
            
End;

Procedure ActualizarFilePedidos(UltimoPedido : Pedido);
Var
	Archivo ,TMPFile  : FilePedidos;
	Maximo : Word;
	I : Integer;
	PedidoTemporal : Pedido;
Begin
	OpenFilePedidos(Archivo);
	OpenFilePedidosTemporal(TMPFile);
	{Teoricamente siempre seria el primero, pero agrego la posibilidad de que no sea correcto}
	Maximo := FileSize(Archivo) - 1;
	For I:= 0 To Maximo Do
	Begin
                Seek(Archivo,I);
            	Read(Archivo,PedidoTemporal);
            	
            	If (PedidoTemporal.Numero <> UltimoPedido.Numero) Then   	 
                        Write(TMPFile,PedidoTemporal);

        End;
            
        Close(Archivo);
        Erase(Archivo);

        Close(TMPFile);
        Rename(TMPFile,'Pedidos.dat');
        
        If (I = 0) Then
                Erase(TMPFile);
End;

Procedure ActualizarCantidadesRepuestos(Var NuevoPedidoReparado: PedidoReparado);
Var
	NuevoRepuesto, RepuestoTemporal : Repuesto;
	Archivo : FileRepuestos;
	Maximo : Word;
	I,Posicion : Integer;
Begin
	Maximo := Length(NuevoPedidoReparado.RepuestosUtilizados);
	Writeln('Maximo:',Maximo);
	For I:=1 To Maximo Do
	Begin
            	NuevoRepuesto := NuevoPedidoReparado.RepuestosUtilizados[I];            	
            	Writeln('Codigo:',NuevoRepuesto.Codigo);
            	If NuevoRepuesto.Codigo <> 0 Then
            	Begin   	
                  	Posicion := BuscarPosicionRepuesto(NuevoRepuesto);
                	Writeln('Posicion :', Posicion);
                	If Posicion > -1 Then
                	Begin
     	                        OpenFileRepuestos(Archivo);
                            	
                            	Seek(Archivo,Posicion);
                            	Read(Archivo,RepuestoTemporal);
               	                RepuestoTemporal.Cantidad := (RepuestoTemporal.Cantidad - NuevoRepuesto.Cantidad);
                            	Writeln('Repuesto Temporal Cantidad: ',RepuestoTemporal.Cantidad);
                            	Write(Archivo,RepuestoTemporal);
                	        Close(Archivo);
                	End;
            	End;
	End;
        Writeln('Algo paso..');
        
End;

Procedure RegistrarReparacion(Var PedidosFaltantes: TP_PedidosFaltantes; Var RepuestosFaltantes: TP_RepuestosFaltantes);
Var
	PedidoAntiguo : Pedido;
	NuevoPedidoReparado : PedidoReparado;
        Mensaje : String;
Begin
	        
        PedidoAntiguo := ObtenerPedidoAntiguo();
        
        If (PedidoAntiguo.Numero <> 0) Then
        Begin
	        InicializarReparados(NuevoPedidoReparado);
	        VisualizarPedido(PedidoAntiguo);
	        CargaRespuestosNecesarios(NuevoPedidoReparado, PedidosFaltantes, RepuestosFaltantes);

                If NoEstaVacio(NuevoPedidoReparado.RepuestosUtilizados) Then
                Begin
	                NuevoPedidoReparado.Numero := GenerarNumeroReparacion();
	                NuevoPedidoReparado.Fecha  := CalcularFechaHoy();
	                
                	ActualizarPedidosReparados(NuevoPedidoReparado);
                        ActualizarFilePedidos(PedidoAntiguo);
                        ActualizarCantidadesRepuestos(NuevoPedidoReparado);
            
	                {MensajeActualizacion(PedidoAntiguo);}
	        End
	        Else
	        Begin
                       Mensaje := 'No se cargaron repuestos. No se reparara el pedido'; 	       
	               MensajeDelSistema(Mensaje);
	        End
	End
	Else
	Begin
	        Mensaje := 'No hay pedidos pendientes de reparacion';
                MensajeDelSistema(Mensaje);
        End;

End;
{*** /Registrar Reparacion ***}

{***El menu principal***}
Procedure MenuPrincipal();
Var
	Opcion : Integer;
	PedidosFaltantes:   TP_PedidosFaltantes;
	RepuestosFaltantes: TP_RepuestosFaltantes;
Begin
        PedidosFaltantes   := Nil;
        RepuestosFaltantes := Nil;

	Repeat
    	Writeln('-----------------Menu Principal--------------------');
    	Writeln('1 - Agregar un nuevo pedido de reparacion');
    	Writeln('2 - Registrar la reparacion de un electrodomesticos');
    	Writeln('3 - Ver Faltante de repuestos');
    	Writeln('4 - Salir');
    	Writeln('-----------------Menu Principal--------------------');
    	Readln(Opcion);

   	ClrScr;

    	Case Opcion Of
        	1:AgregarPedidoReparacion();
        	2:RegistrarReparacion(PedidosFaltantes, RepuestosFaltantes);
        	3:VerFaltantesRepuestos(PedidosFaltantes, RepuestosFaltantes);
    	End;

	Until (Opcion = 4);
	
	DestruirListas(PedidosFaltantes, RepuestosFaltantes);
End;
{*********/Procedimientos y Funciones*************}
Begin
    	ClrScr;
    	MenuPrincipal();
End.
